home *** CD-ROM | disk | FTP | other *** search
/ ftp.mactech.com 2010 / ftp.mactech.com.tar / ftp.mactech.com / machack / Hacks95 / Aaron 1.0b3.sit / Aaron 1.0b3 / Aaron Source / CDEF and Patches / PPCPatches.c < prev    next >
Text File  |  1995-06-24  |  19KB  |  720 lines
  1. /*    Aaron © 1995 Gregory D. Landweber, ALL RIGHTS RESERVED    */
  2.     
  3. #include <Processes.h>
  4. #include <GestaltEqu.h>
  5. #include <FragLoad.h>
  6. #include "CDEF.h"
  7.  
  8. #define IsFinder() (GetProcessSignature() == 'MACS')
  9.  
  10. OSType GetProcessSignature ( void );
  11.  
  12. // for the blue menu highlighting hack
  13. pascal void    MyRGBBackColor ( RGBColor *theColor );
  14. pascal void    MyRGBForeColor ( RGBColor *theColor );
  15.  
  16. // for menu bar tinge
  17. pascal void    MyDrawMenuBar ( void );
  18.  
  19. // for the gray Finder info header
  20. pascal void    MyBeginUpdate ( WindowPtr theWindow );    // copland
  21.  
  22. // to install the CDEFs, etc.
  23. pascal Handle    MyGetResource ( ResType rType, short rID );
  24.  
  25. // to keep the resource file open permanently
  26. pascal void    MyCloseResFile ( short rfRefNum );
  27.  
  28. // globals
  29.  
  30. enum {
  31.     iRGBBackColor = 0,
  32.     iRGBForeColor,
  33.     iDrawMenuBar,
  34.     iBeginUpdate,
  35.     iGetResource,
  36.     iCloseResFile
  37. };
  38.  
  39. typedef struct {
  40.     short    systemFont;
  41.     short    refNum;
  42.     
  43.     short    buttonsCDEF;
  44.     short    newFolderCDEF;
  45.     
  46.     short    sysFontNum;
  47. }    PrefsRecord;
  48.  
  49. PrefsRecord    *gPrefs;
  50.  
  51. typedef struct {
  52.     RGBColor    finderColor;
  53.     RGBColor    dialogColor;
  54.     
  55.     Boolean    colorFinder;
  56.     Boolean    colorDialogs;
  57.     Boolean    colorButtons;
  58.     Boolean    changeFont;
  59.     
  60.     short    systemFont;
  61.     short    sysFontFam;
  62.     long        sysVersion;
  63.     short    refNum;
  64.     
  65.     short    buttonsCDEF;
  66.     short    newFolderCDEF;
  67.     
  68.     short    sysFontNum;
  69.     
  70.     Boolean    finderLabel;
  71. }    GBPrefsRecord;
  72.  
  73. #ifndef __powerc // 680x0 Code
  74.  
  75. #include <A4Stuff.h>
  76.  
  77. void GetIconType ( void );
  78. void KeepMeAround ( void );
  79. pascal OSErr MyGestaltSelector ( OSType selector, long *response );
  80. void main ( short refNum );
  81.  
  82. UniversalProcPtr    gOriginalTraps[6];
  83. PrefsRecord        gPrefsRec;
  84.  
  85. typedef pascal void ( *RGBBackColorType ) ( RGBColor * );
  86. typedef pascal void ( *BeginUpdateType ) ( WindowPtr );
  87. typedef pascal Handle ( *GetResourceType ) ( ResType rType, short rID );
  88. typedef pascal void ( *CloseResFileType ) ( short );
  89. typedef pascal void ( *DrawMenuBarType ) ( void );
  90.  
  91. void _MyRGBBackColor ( void );
  92. void _MyRGBForeColor ( void );
  93. void _MyBeginUpdate ( void );
  94. void _MyGetResource ( void );
  95. void _MyCloseResFile ( void );
  96. void _MyDrawMenuBar ( void );
  97.  
  98. asm void _MyRGBBackColor ( void )
  99. {
  100.     movem.l    d0/d1/d2/a1/a4,-(sp);
  101.     jsr        SetCurrentA4;
  102.     move.l    24(sp),-(sp);
  103.     jsr        MyRGBBackColor;
  104.     movem.l    (sp)+,d0/d1/d2/a1/a4;
  105.     move.l    (sp)+,a0;
  106.     addq.l    %4,sp;
  107.     jmp        (a0);
  108. }
  109.  
  110. asm void _MyRGBForeColor ( void )
  111. {
  112.     movem.l    d0/d1/d2/a1/a4,-(sp);
  113.     jsr        SetCurrentA4;
  114.     move.l    24(sp),-(sp);
  115.     jsr        MyRGBForeColor;
  116.     movem.l    (sp)+,d0/d1/d2/a1/a4;
  117.     move.l    (sp)+,a0;
  118.     addq.l    %4,sp;
  119.     jmp        (a0);
  120. }
  121.  
  122. asm void _MyBeginUpdate ( void )
  123. {
  124.     movem.l    d0/d1/d2/a1/a4,-(sp);
  125.     jsr        SetCurrentA4;
  126.     move.l    24(sp),-(sp);
  127.     jsr        MyBeginUpdate;
  128.     movem.l    (sp)+,d0/d1/d2/a1/a4;
  129.     move.l    (sp)+,a0;
  130.     addq.l    %4,sp;
  131.     jmp        (a0);
  132. }
  133.  
  134. asm void _MyGetResource ( void )
  135. {
  136.     movem.l    d0/d1/d2/a1/a4,-(sp);
  137.     jsr        SetCurrentA4;
  138.     subq.l    %4,sp;
  139.     move.l    30(sp),-(sp);
  140.     move.w    32(sp),-(sp);
  141.     jsr        MyGetResource;
  142.     move.l    (sp)+,30(sp);
  143.     movem.l    (sp)+,d0/d1/d2/a1/a4;
  144.     move.l    (sp)+,a0;
  145.     addq.l    %6,sp;
  146.     move.w    0x0a60,d0;
  147.     ext.l        d0;
  148.     jmp        (a0);
  149. }
  150.  
  151. asm void _MyCloseResFile ( void )
  152. {
  153.     movem.l    d0/d1/d2/a1/a4,-(sp);
  154.     jsr        SetCurrentA4;
  155.     move.w    24(sp),-(sp);
  156.     jsr        MyCloseResFile;
  157.     movem.l    (sp)+,d0/d1/d2/a1/a4;
  158.     move.l    (sp)+,a0;
  159.     addq.l    %2,sp;
  160.     jmp        (a0);
  161. }
  162.  
  163. asm void _MyDrawMenuBar ( void )
  164. {
  165.     movem.l    d0/d1/d2/a1/a4,-(sp);
  166.     jsr        SetCurrentA4;
  167.     jsr        MyDrawMenuBar;
  168.     movem.l    (sp)+,d0/d1/d2/a1/a4;
  169.     rts;
  170. }
  171.  
  172. #else // PowerPC code
  173.  
  174. void main ( UniversalProcPtr *, UniversalProcPtr *, PrefsRecord * );
  175.  
  176. enum {
  177.     uppRGBBackColorProcInfo = kPascalStackBased
  178.         | STACK_ROUTINE_PARAMETER(1, kFourByteCode),
  179.     uppBeginUpdateProcInfo = kPascalStackBased
  180.         | STACK_ROUTINE_PARAMETER(1, kFourByteCode),
  181.     uppGetResourceProcInfo = kPascalStackBased
  182.         | RESULT_SIZE(kFourByteCode)
  183.         | STACK_ROUTINE_PARAMETER(1, kFourByteCode)
  184.         | STACK_ROUTINE_PARAMETER(2, kTwoByteCode),
  185.     uppCloseResFileProcInfo = kPascalStackBased
  186.         | STACK_ROUTINE_PARAMETER(1, kTwoByteCode),
  187.     uppMainProcInfo = kCStackBased
  188.         | STACK_ROUTINE_PARAMETER(1, kFourByteCode)
  189.         | STACK_ROUTINE_PARAMETER(2, kFourByteCode)
  190.         | STACK_ROUTINE_PARAMETER(3, kFourByteCode),
  191.     uppDrawMenuBarProcInfo = kPascalStackBased
  192. };
  193.  
  194. UniversalProcPtr    *gOriginalTraps;
  195.  
  196. ProcInfoType __procinfo = uppMainProcInfo;
  197.  
  198. #endif
  199.  
  200. typedef struct _res_map res_map;
  201. typedef struct _res_map *res_map_ptr;
  202. typedef struct _res_map **res_map_handle;
  203.  
  204. struct _res_map {
  205.     long                void1;        /* Reserved */
  206.     long                void2;        /* Reserved */
  207.     long                void3;        /* Reserved */
  208.     long                void4;        /* Reserved */
  209.     res_map_handle    next_map;    /* Handle of next resource map */
  210.     short            refNum;        /* fRefNum for this file */
  211.     short            fileAttrs;        /* Resource file attributes for this file */
  212.     short            tlOffset;        /* Type List Offset from beginning of map */
  213.     short            nlOffset;        /* Name List Offset from beginning of map */
  214. };
  215.  
  216. pascal void MyCloseResFile ( short refNum )
  217. {
  218.     if ( refNum == gPrefs->refNum ) {
  219.         UpdateResFile ( refNum );
  220.         if ( CurResFile() == refNum )
  221.             UseResFile ( (*(res_map_handle)LMGetTopMapHndl())->refNum );
  222.     }
  223.     else
  224. #ifndef __powerc
  225.         ( *(CloseResFileType)gOriginalTraps[iCloseResFile] ) ( refNum );
  226. #else
  227.         CallUniversalProc ( gOriginalTraps[iCloseResFile], uppCloseResFileProcInfo,
  228.                             refNum );
  229. #endif
  230. }
  231.  
  232. struct TIconObject;
  233. //struct TIconObject71;
  234. struct TIconListObject;
  235. struct TWindowObject;
  236.  
  237. struct TIconListObject
  238. {
  239.     long                        fByteCount;
  240.     long                        fByteSize;
  241.     struct TIconObject**        fObjects[1];
  242. };
  243.  
  244. struct TIconObject {
  245.     char                    stuff0[0x08];        // 00
  246.     char                    fLabel;            // 08
  247.     char                    stuff6;            // 09
  248.     struct TIconObject**    fParent;            // 0A
  249.     char                    stuff1[0x0A];        // 0E
  250.     struct TIconListObject**    fChildren;            // 18
  251.     struct TWindowObject**    fMainWindow;        // 1C
  252.     char                    stuff2[4];            // 20
  253.     unsigned                stuff3    : 12;        // 24
  254.     unsigned                fSelected    : 1;        // 25:3
  255.     char                    stuff4[0x06];        // 26
  256.     long                    fCNID;            // 2C
  257.     short                fVRefNum;        // 30
  258.     char                    stuff5[0x1B];        // 32
  259. };
  260.  
  261.  
  262. struct TWindowObject {
  263.     long                    fVTablePtr;
  264.     WindowPtr            fWindow;
  265.     struct TIconObject**    fOwner;
  266.     long                     fThing;
  267.     WindowPtr             fPort;
  268. };
  269.  
  270. pascal void MyBeginUpdate ( WindowPtr theWindow )
  271. {
  272.     char **refCon;
  273.     
  274. #define kFinderWindowKind 20
  275.  
  276.     if (     ( ((WindowPeek)theWindow)->windowKind == kFinderWindowKind ) &&
  277.         ((WindowPeek)theWindow)->visible &&
  278.         ( refCon = (char **)GetWRefCon ( theWindow ) ) &&
  279.         ( GetWVariant ( theWindow ) == zoomDocProc ) && IsFinder() &&
  280.         (*(*(struct TWindowObject **)refCon)->fOwner)->fParent ) {
  281.         
  282.         InsetRgn ( ((WindowPeek)theWindow)->updateRgn, -1, 0 );
  283.     }    
  284.     
  285. #ifndef __powerc
  286.     ( *(BeginUpdateType)gOriginalTraps[iBeginUpdate] ) ( theWindow );
  287. #else
  288.     CallUniversalProc ( gOriginalTraps[iBeginUpdate], uppBeginUpdateProcInfo,
  289.                         theWindow );
  290. #endif
  291.  
  292.     if (     ( ((WindowPeek)theWindow)->windowKind == kFinderWindowKind ) &&
  293.         ((WindowPeek)theWindow)->visible &&
  294.         ( refCon = (char **)GetWRefCon ( theWindow ) ) &&
  295.         ( GetWVariant ( theWindow ) == zoomDocProc ) && IsFinder() &&
  296.         (*(*(struct TWindowObject **)refCon)->fOwner)->fParent ) {
  297.         GrafPtr    savePort;
  298.         Rect        theRect;
  299.         FontInfo    fInfo;
  300.         short    temp;
  301.         Handle    finderPrefs = GetResource ( 'fval', 128 );
  302.         
  303.         GetPort ( &savePort );
  304.         SetPort ( theWindow );
  305.         
  306.         GetFontInfo ( &fInfo );
  307.         if ( finderPrefs && *finderPrefs && ((char *)*finderPrefs)[0x17] && (*refCon)[0x29]  >= 2 ) {
  308.             temp = ( ( fInfo.ascent + fInfo.descent ) * 19 - 15 ) / 6;
  309.             if ( temp < 26 )
  310.                 temp = 26;
  311.         }
  312.         else {
  313.             temp = ( ( fInfo.ascent + fInfo.descent ) * 5 - 8 ) / 3;
  314.             if ( temp < 17 )
  315.                 temp = 17;
  316.         }
  317.             
  318.         theRect = theWindow->portRect;
  319.         theRect.bottom = theRect.top + temp;
  320.         
  321.         {
  322.             RGBColor    saveBackColor, saveForeColor;
  323.             RGBColor    grayBackColor    = { 0xdddd, 0xdddd, 0xdddd };
  324.             RGBColor    whiteForeColor    = { 0xFFFF, 0xFFFF, 0xFFFF };
  325.             RGBColor    darkForeColor    = { 0xaaaa, 0xaaaa, 0xaaaa };
  326.             Point        saveLoc;
  327.             
  328.             GetPen ( &saveLoc );
  329.             
  330.             GetBackColor ( &saveBackColor );
  331.             GetForeColor ( &saveForeColor );
  332.             
  333.             RGBBackColor ( &grayBackColor );
  334.             EraseRect ( &theRect );
  335.             
  336.             RGBBackColor ( &whiteForeColor );
  337.             RGBForeColor ( &whiteForeColor );
  338.             MoveTo ( theRect.left, theRect.bottom - 1 );
  339.             LineTo ( theRect.left, theRect.top );
  340.             LineTo ( theRect.right - 1, theRect.top );
  341.             
  342.             RGBBackColor ( &darkForeColor );
  343.             RGBForeColor ( &darkForeColor );
  344.             MoveTo ( theRect.left, theRect.bottom - 1 );
  345.             LineTo ( theRect.right - 1, theRect.bottom - 1 );
  346.             LineTo ( theRect.right - 1, theRect.top );
  347.             
  348.             RGBBackColor ( &saveBackColor );
  349.             RGBForeColor ( &saveForeColor );
  350.             
  351.             MoveTo ( saveLoc.h, saveLoc.v );
  352.         }
  353.             
  354.         SetPort ( savePort );
  355.     }
  356. }
  357.  
  358. pascal void MyRGBForeColor ( RGBColor *theColor )
  359. {
  360.     if ( theColor->red == 0xdddc && theColor->green == 0xdddc && theColor->blue == 0xdddc )
  361.         theColor->red = theColor->green = theColor->blue = 0xFFFE;
  362.         
  363.     if ( theColor->red == 0x0001 && theColor->green == 0x0001 && theColor->blue == 0x7778 )
  364.         theColor->red = theColor->green = theColor->blue = 0x0001;
  365.  
  366. #ifndef __powerc
  367.     ( *(RGBBackColorType)gOriginalTraps[iRGBForeColor] ) ( theColor );
  368. #else
  369.     CallUniversalProc ( gOriginalTraps[iRGBForeColor], uppRGBBackColorProcInfo, theColor );
  370. #endif
  371. }
  372.  
  373. pascal void MyRGBBackColor ( RGBColor *theColor )
  374. {
  375.     if ( theColor->red == 0x0001 && theColor->green == 0x0001 && theColor->blue == 0x0001 ) {
  376.         theColor->red = theColor->green = 0x0001;
  377.         theColor->blue = 0x7778;
  378.     }
  379.         
  380.     if ( theColor->red == 0xFFFE && theColor->green == 0xFFFE && theColor->blue == 0xFFFE )
  381.         theColor->red = theColor->green = theColor->blue = 0xdddc;
  382.  
  383. #ifndef __powerc
  384.     ( *(RGBBackColorType)gOriginalTraps[iRGBBackColor] ) ( theColor );
  385. #else
  386.     CallUniversalProc ( gOriginalTraps[iRGBBackColor], uppRGBBackColorProcInfo,
  387.                         theColor );
  388. #endif
  389. }
  390.  
  391. pascal void MyDrawMenuBar ( void )
  392. {
  393. #ifndef __powerc
  394.     ( *(DrawMenuBarType)gOriginalTraps[iDrawMenuBar] ) ();
  395. #else
  396.     CallUniversalProc ( gOriginalTraps[iDrawMenuBar], uppDrawMenuBarProcInfo );
  397. #endif
  398.  
  399. //    if ( LMGetCurApRefNum() ) {
  400.     {
  401.         short    theHeight;
  402.         RGBColor    saveColor, theColor = { 0x8888, 0x8888, 0x8888 },
  403.                 whiteColor = { 0xFFFF, 0xFFFF, 0xFFFF };
  404.         GrafPtr    savePort, myPort;
  405.         GDHandle    theDevice = GetMainDevice();
  406.         
  407.         theHeight = LMGetMBarHeight();
  408.         if ( theHeight > 0 ) {
  409.             GetPort ( &savePort );
  410.             GetCWMgrPort ( (CGrafPtr *)&myPort );
  411.             SetPort ( myPort );    
  412.             GetForeColor ( &saveColor );
  413.             RGBForeColor ( &theColor );
  414.             MoveTo ( (*theDevice)->gdRect.left, (*theDevice)->gdRect.top + theHeight - 2 );
  415.             LineTo ( (*theDevice)->gdRect.right, (*theDevice)->gdRect.top + theHeight - 2 );
  416.             RGBForeColor ( &whiteColor );
  417.             MoveTo ( (*theDevice)->gdRect.left + 5, (*theDevice)->gdRect.top );
  418.             LineTo ( (*theDevice)->gdRect.right - 6, (*theDevice)->gdRect.top );
  419.             RGBForeColor ( &theColor );
  420.             SetPort ( savePort );
  421.         }
  422.     }
  423. }
  424.  
  425. OSType GetProcessSignature ( void )
  426. {
  427.     ProcessSerialNumber    PSN = { 0, kCurrentProcess };
  428.     ProcessInfoRec        info;
  429.     
  430.     if ( ( LMGetCurApRefNum() == 0 ) || ( LMGetCurApName()[0] > 31 ) )
  431.         return 0;
  432.     
  433.     info.processInfoLength = sizeof(info);    
  434.     info.processName    = nil;
  435.     info.processAppSpec = nil;
  436.     GetProcessInformation ( &PSN, &info );
  437.     return info.processSignature;
  438. }
  439.  
  440. #ifndef __powerc
  441. #define OriginalGetResource(rType,rID) \
  442.     ( *(GetResourceType)gOriginalTraps[iGetResource] ) ( rType, rID )
  443. #else
  444. #define OriginalGetResource(rType,rID) \
  445.     (Handle) CallUniversalProc ( gOriginalTraps[iGetResource], uppGetResourceProcInfo, \
  446.                                  rType, rID )
  447. #endif
  448.  
  449. Handle GetResourceFromMyFile ( ResType rType, short rID );
  450.  
  451. Handle GetResourceFromMyFile ( ResType rType, short rID )
  452. {
  453.     short    refNum = CurResFile();
  454.     Handle    theHandle;
  455.     
  456.     UseResFile ( gPrefs->refNum );
  457.     theHandle = Get1Resource ( rType, rID );
  458.     UseResFile ( refNum );
  459.     return theHandle;
  460. }
  461.  
  462. pascal Handle MyGetResource ( ResType rType, short rID )
  463. {
  464.     unsigned char    oldRomMapInsert;
  465.     unsigned char    oldTmpResLoad;
  466.     Handle        theHandle;
  467.     Boolean        done = false;
  468.     GBPrefsRecord    *gbPrefs;
  469.     
  470.     oldRomMapInsert = LMGetROMMapInsert();
  471.     oldTmpResLoad    = LMGetTmpResLoad();
  472.  
  473.     switch ( rType ) {
  474.         case 'ICN#' :
  475.         case 'icl4' :
  476.         case 'icl8' :
  477.         case 'ics#' :
  478.         case 'ics4' :
  479.         case 'ics8' :
  480.             if (    rID == -16494 || rID == -16482 || rID == -16386 || rID == -3999 || rID == -3994 ||
  481.                 rID == -3993 || ( rID >= -3984 && rID <= -3973 ) || rID == -3968  ) {
  482.                 theHandle = GetResourceFromMyFile ( rType, rID );
  483.                 if ( theHandle )
  484.                     done = true;
  485.             }
  486.             break;
  487.         case 'WDEF' :
  488.             if ( rID == 0 ) {
  489.                 Handle    theWDEF;
  490.                 short    refNum;
  491.                 
  492.                 theHandle = OriginalGetResource ( 'WDEF', 0 );
  493.  
  494.                 refNum = CurResFile();
  495.                 UseResFile ( 0 );
  496.                 theWDEF = OriginalGetResource ( 'WDEF', 0 );
  497.                 UseResFile ( refNum );
  498.                 
  499.                 if ( theHandle == theWDEF ) {
  500.                     theHandle = GetResourceFromMyFile ( rType, rID );
  501.                     if ( theHandle )
  502.                         done = true;
  503.                 }
  504.                 else
  505.                     done = true;
  506.             }
  507.             break;
  508.         case 'CDEF' :
  509.             if ( rID == 1 ) {
  510.                 theHandle = GetResourceFromMyFile ( rType, rID );
  511.                 if ( theHandle )
  512.                     done = true;
  513.                 break;
  514.             }
  515.             // Let Greg's Buttons override us
  516.             if (    ( Gestalt ( 'GrEG', (long *)&gbPrefs ) == noErr ) && gbPrefs->colorButtons )
  517.                 break;
  518.             
  519.             if ( rID == 61 ) {
  520.                 theHandle = GetResourceFromMyFile ( rType, rID );
  521.                 if ( theHandle )
  522.                     done = true;
  523.                 break;
  524.             }
  525.             if ( rID == 0 ) {
  526.                 Handle    theCDEF;
  527.                 short    refNum;
  528.                 short    resID = gPrefs->buttonsCDEF;
  529.                 
  530.                 theHandle = OriginalGetResource ( 'CDEF', 0 );
  531.  
  532.                 refNum = CurResFile();
  533.                 UseResFile ( 0 );
  534.                 theCDEF = OriginalGetResource ( 'CDEF', 0 );
  535.                 UseResFile ( refNum );
  536.                 
  537.                 // Hack to avoid loading PowerPC CDEF within a Desk Accessory
  538.                 if ( ( resID == 2 ) &&
  539.                      LMGetCurApRefNum() && ( LMGetCurApName()[0] <= 31 ) ) {
  540.                     ProcessSerialNumber    PSN = { 0, kCurrentProcess };
  541.                     ProcessInfoRec        info;
  542.  
  543.                     info.processInfoLength = sizeof(info);    
  544.                     info.processName    = nil;
  545.                     info.processAppSpec = nil;
  546.                     GetProcessInformation ( &PSN, &info );
  547.                     if ( info.processType == 'dfil' )
  548.                         resID = 0;
  549.                     //if ( info.processSignature == 'SII2' )    // Suitcase Fix
  550.                     if ( info.processType == 'INIT' )
  551.                         resID = 0;
  552.                 }
  553.                 // End of DA hack
  554.                 
  555.                 if ( theHandle == theCDEF ) {
  556.                     theHandle = GetResourceFromMyFile ( 'CDEF', resID );
  557.                     if ( theHandle )
  558.                         done = true;
  559.                 }
  560.                 else
  561.                     done = true;
  562.             }
  563.             break;
  564.         case 'NFNT' :
  565.             // Let Greg's Buttons override us
  566.             if (    ( Gestalt ( 'GrEG', (long *)&gbPrefs ) == noErr ) && gbPrefs->changeFont )
  567.                 break;
  568.             
  569.             if ( ( rID == gPrefs->sysFontNum ) || ( rID == -116 ) )
  570.                 rID = gPrefs->systemFont;
  571.         break;
  572.     }
  573.     
  574.     if ( !done ) {
  575.         LMSetROMMapInsert(oldRomMapInsert);
  576.         LMSetTmpResLoad(oldTmpResLoad);
  577.         theHandle = OriginalGetResource ( rType, rID );
  578.     }
  579.         
  580.     return theHandle;
  581. }
  582.  
  583. #ifndef __powerc    // 680x0 code
  584.  
  585. // 680x0 code only
  586.  
  587. pascal OSErr MyGestaltSelector ( OSType selector, long *response )
  588. {
  589.     long    oldA4 = SetCurrentA4();
  590.     
  591.     *response = (long)gPrefs->refNum;
  592.     
  593.     SetA4( oldA4 );
  594.     return noErr;
  595. }
  596.  
  597. /*
  598. pascal OSErr MyGestaltSelector ( OSType selector, long *response )
  599. {
  600.     long    oldA4 = SetCurrentA4();
  601.     
  602.     *response = (long)gPrefs;
  603.     
  604.     SetA4( oldA4 );
  605.     return noErr;
  606. }
  607. */
  608.  
  609. // 680x0 code only
  610.  
  611. void main ( short refNum )
  612. {
  613.     UniversalProcPtr    newTraps[6];
  614.     long                result;
  615.                                                 
  616.     long                oldA4;
  617.  
  618.     oldA4 = SetCurrentA4();
  619.     
  620.     newTraps[iRGBBackColor]    = (ProcPtr)_MyRGBBackColor;
  621.     newTraps[iRGBForeColor]    = (ProcPtr)_MyRGBForeColor;
  622.     newTraps[iBeginUpdate]    = (ProcPtr)_MyBeginUpdate;
  623.     newTraps[iGetResource]    = (ProcPtr)_MyGetResource;
  624.     newTraps[iCloseResFile]    = (ProcPtr)_MyCloseResFile;
  625.     newTraps[iDrawMenuBar]    = (ProcPtr)_MyDrawMenuBar;
  626.     
  627.     gPrefs = &gPrefsRec;
  628.     gPrefs->refNum = refNum;
  629.     gPrefs->buttonsCDEF = 0;
  630.     gPrefs->newFolderCDEF = 61;
  631.     gPrefs->systemFont = 16301;
  632.     
  633.     //     Check the FOND for the system font to determine the FONT/NFNT ID of the size
  634.     //    12 bitmap, for which we substitute our own.
  635.     {
  636.         Handle    theFOND;
  637.         short    numFonts;
  638.         
  639.         UseResFile ( 0 );
  640.         theFOND = GetResource ( 'FOND', LMGetSysFontFam() );
  641.         UseResFile ( refNum );
  642.         
  643.         gPrefs->sysFontNum = 12;
  644.         if ( theFOND && *theFOND )
  645.             for ( numFonts = *(short *)(*theFOND + 52 ); numFonts >= 0; numFonts-- )
  646.                 if ( *(long *)(*theFOND + 54 + 6 * numFonts ) == 0x000C0000 ) {
  647.                     gPrefs->sysFontNum = *(short *)(*theFOND + 58 + 6 * numFonts );
  648.                     break;
  649.                 }
  650.     }
  651.     
  652.     NewGestalt ( 'Copl', MyGestaltSelector );
  653.     
  654. //    if ( NewGestalt ( 'GrEG', MyGestaltSelector ) == noErr ) {
  655.  
  656.     gOriginalTraps[iRGBBackColor]    = GetToolTrapAddress ( _RGBBackColor );
  657.     gOriginalTraps[iRGBForeColor]    = GetToolTrapAddress ( _RGBForeColor );
  658.     gOriginalTraps[iBeginUpdate]    = GetToolTrapAddress ( _BeginUpDate );
  659.     gOriginalTraps[iGetResource]    = GetToolTrapAddress ( _GetResource );
  660.     gOriginalTraps[iCloseResFile]    = GetToolTrapAddress ( _CloseResFile );
  661.     gOriginalTraps[iDrawMenuBar]    = GetToolTrapAddress ( _DrawMenuBar );
  662.     
  663.     if ( ( Gestalt ( gestaltMixedModeAttr, &result ) == noErr ) &&
  664.          ( result & ( 1 << gestaltPowerPCAware ) ) ) {
  665.         Handle            theHandle;
  666.         
  667.         theHandle = GetResource ( 'PACH', 131 );
  668.         if ( theHandle && *theHandle ) {
  669.             DetachResource ( theHandle );
  670.             ( ( void (*) ( UniversalProcPtr *, UniversalProcPtr *, PrefsRecord * ) ) *theHandle )
  671.                 ( gOriginalTraps, newTraps, gPrefs );
  672.         }
  673.     }
  674.     
  675.     SetToolTrapAddress ( newTraps[iRGBBackColor],    _RGBBackColor );
  676.     SetToolTrapAddress ( newTraps[iRGBForeColor],    _RGBForeColor );
  677.     SetToolTrapAddress ( newTraps[iBeginUpdate],        _BeginUpDate );
  678.     SetToolTrapAddress ( newTraps[iGetResource],    _GetResource );
  679.     SetToolTrapAddress ( newTraps[iCloseResFile],    _CloseResFile );
  680.     SetToolTrapAddress ( newTraps[iDrawMenuBar],    _DrawMenuBar );
  681.         
  682. //    }
  683.     
  684.     SetA4 ( oldA4 );
  685. }
  686.  
  687. #else    // PowerPC code
  688.  
  689. // PowePC code only
  690.  
  691. void main ( UniversalProcPtr *originalTraps, UniversalProcPtr *newTraps, PrefsRecord *prefs )
  692. {
  693.     THz    saveZone = GetZone();
  694.     
  695.     SetZone ( SystemZone() );
  696.     gPrefs = prefs;
  697.     gOriginalTraps    = originalTraps;
  698.     
  699.     newTraps[iRGBBackColor]    = NewFatRoutineDescriptor
  700.         ( (ProcPtr)newTraps[iRGBBackColor],    (ProcPtr)MyRGBBackColor,    uppRGBBackColorProcInfo );
  701.     newTraps[iRGBForeColor]    = NewFatRoutineDescriptor
  702.         ( (ProcPtr)newTraps[iRGBForeColor],    (ProcPtr)MyRGBForeColor,    uppRGBBackColorProcInfo );
  703.     newTraps[iBeginUpdate]    = NewFatRoutineDescriptor
  704.         ( (ProcPtr)newTraps[iBeginUpdate],        (ProcPtr)MyBeginUpdate,        uppBeginUpdateProcInfo );
  705.     newTraps[iGetResource]    = NewFatRoutineDescriptor
  706.         ( (ProcPtr)newTraps[iGetResource],        (ProcPtr)MyGetResource,        uppGetResourceProcInfo );
  707.     newTraps[iCloseResFile]    = NewFatRoutineDescriptor
  708.         ( (ProcPtr)newTraps[iCloseResFile],        (ProcPtr)MyCloseResFile,        uppCloseResFileProcInfo );
  709.     newTraps[iDrawMenuBar]    = NewFatRoutineDescriptor
  710.         ( (ProcPtr)newTraps[iDrawMenuBar],    (ProcPtr)MyDrawMenuBar,    uppDrawMenuBarProcInfo );
  711.  
  712.     gPrefs->buttonsCDEF   = 2;
  713.     gPrefs->newFolderCDEF = 61;
  714.     
  715.     SetZone ( saveZone );
  716. }
  717.     
  718. #endif
  719.  
  720.